diff --git a/system/application/config/autoload.php b/system/application/config/autoload.php
index 26e71f7..85b65aa 100644
--- a/system/application/config/autoload.php
+++ b/system/application/config/autoload.php
@@ -82,6 +82,21 @@
 
 /*
 | -------------------------------------------------------------------
+|  Auto-load Language files
+| -------------------------------------------------------------------
+| Prototype:
+|
+|	$autoload['language'] = array('lang1', 'lang2');
+|
+| NOTE: Do not include the "_lang" part of your file.  For example 
+| "codeigniter_lang.php" would be referenced as array('codeigniter');
+|
+*/
+
+$autoload['language'] = array('');
+
+/*
+| -------------------------------------------------------------------
 |  Auto-load Core Libraries
 | -------------------------------------------------------------------
 |
diff --git a/system/libraries/Language.php b/system/libraries/Language.php
index 26775ec..94923a3 100644
--- a/system/libraries/Language.php
+++ b/system/libraries/Language.php
@@ -89,11 +89,6 @@
 			return;
 		}
 		
-		if ($return == TRUE)
-		{
-			return $lang;
-		}
-		
 		$this->is_loaded[] = $langfile;
 		$this->language = array_merge($this->language, $lang);
 		unset($lang);
diff --git a/system/libraries/Loader.php b/system/libraries/Loader.php
index abe3a1c..7fa46c3 100644
--- a/system/libraries/Loader.php
+++ b/system/libraries/Loader.php
@@ -481,13 +481,24 @@
 	 * Loads a language file
 	 *
 	 * @access	public
+	 * @param	array
 	 * @param	string
+	 * @param	bool
 	 * @return	void
 	 */
-	function language($file = '', $lang = '', $return = FALSE)
+	function language($file = array(), $lang = '')
 	{
 		$CI =& get_instance();
-		return $CI->lang->load($file, $lang, $return);
+
+		if ( ! is_array($file))
+		{
+			$file = array($file);
+		}
+
+		foreach ($file as $langfile)
+		{	
+			$CI->lang->load($langfile, $lang);
+		}
 	}
 	
 	// --------------------------------------------------------------------
@@ -813,7 +824,7 @@
 			return FALSE;
 		}
 		
-		// Load any custome config file
+		// Load any custom config file
 		if (count($autoload['config']) > 0)
 		{			
 			$CI =& get_instance();
@@ -823,15 +834,15 @@
 			}
 		}		
 
-		// Load plugins, helpers, and scripts
-		foreach (array('helper', 'plugin', 'script') as $type)
-		{
+		// Autoload plugins, helpers, scripts and languages
+		foreach (array('helper', 'plugin', 'script', 'language') as $type)
+		{			
 			if (isset($autoload[$type]) AND count($autoload[$type]) > 0)
 			{
 				$this->$type($autoload[$type]);
 			}		
 		}
-		
+
 		// A little tweak to remain backward compatible
 		// The $autoload['core'] item was deprecated
 		if ( ! isset($autoload['libraries']))
diff --git a/user_guide/changelog.html b/user_guide/changelog.html
index d8ffd8b..0456be3 100644
--- a/user_guide/changelog.html
+++ b/user_guide/changelog.html
@@ -65,11 +65,12 @@
 <h2>Version 1.5.4</h2>
 <p>Release Date: -- Still under development</p>
 <ul>
-	<li>Added stripslashes() to the _clean_input_data() function in the Input class when magic quotes is on so that data will always be un-slashed within the framework.</li>
-	<li>Added array to string into the profiler </li>
-	<li>Added some additional mime types in application/config/mimes.php</li>
-	<li>Added filename_security() method to Input library</li>
-	<li>Added some additional arguments to the <a href="./helpers/inflector_helper.html">Inflection helper</a> singular() to compensate for words ending in "s".  Also added a force parameter to pluralize()</li>
+	<li>Added <a href="./libraries/language.html">custom Language files</a> to the <a href="./general/autoloader.html">autoload</a> options. </li>
+	<li>Added stripslashes() to the _clean_input_data() function in the <a href="./libraries/input.html">Input class</a> when magic quotes is on so that data will always be un-slashed within the framework.</li>
+	<li>Added array to string into the <a href="general/profiling.html">profiler</a>.</li>
+	<li>Added some additional mime types in application/config/mimes.php.</li>
+	<li>Added filename_security() method to <a href="./libraries/input.html">Input library</a>.</li>
+	<li>Added some additional arguments to the <a href="./helpers/inflector_helper.html">Inflection helper</a> singular() to compensate for words ending in "s".  Also added a force parameter to pluralize().</li>
 	<li>Fixed MSSQL insert_id().</li>
 	<li>Fixed a logic error in the DB trans_status() function.  It was incorrectly returning TRUE on failure and FALSE on success.</li>
 	<li>Fixed a bug that was allowing multiple load attempts on extended classes.</li>
@@ -80,7 +81,7 @@
     <li>Fixed a bug in the <a href="./libraries/zip.html">Zip library</a>, providing PC Zip file compatibility with Mac OS X</li>
     <li>Fixed a bug in router that was ignoring the scaffolding route for optimization </li>
 	<li>Fixed an IP validation bug.</li>
-	<li>Fixed a bug in display of POST keys in the Profiler output</li>
+	<li>Fixed a bug in display of POST keys in the <a href="./general/profiling.html">Profiler</a> output</li>
 	<li>Fixed a bug in display of queries with characters that would be interpreted as HTML in the Profiler output</li>
 	<li>Fixed a bug in display of Email class print debugger with characters that would be interpreted as HTML in the debugging output</li>
 	<li>Fixed a bug in the Content-Transfer-Encoding of HTML emails with the quoted-printable MIME type</li>
@@ -91,7 +92,7 @@
     <li>Modified the Router so that when Query Strings are Enabled, the controller trigger and function trigger values are sanitized for filename include security.</li>
     <li>Modified the is_image() method in the Upload library to take into account Windows IE 6/7 eccentricities when dealing with MIMEs</li>
     <li>Modified XSS Cleaning routine to be more performance friendly and compatible with PHP 5.2's new PCRE backtrack and recursion limits.</li>
-	<li>Modified the URL Helper to type cast the $title as a string in case a numeric value is supplied</li>
+	<li>Modified the <a href="./helpers/url_helper.html">URL Helper</a> to type cast the $title as a string in case a numeric value is supplied</li>
 	<li>Modified Form Helper form_dropdown() to type cast the keys and values of the options array as strings, allowing numeric values to be properly set as 'selected'</li>
 	<li>Deprecated the use if <kbd>is_numeric()</kbd> in various places since it allows periods.  Due to compatibility problems with <kbd>ctype_digit()</kbd>, making it unreliable in some installations, the following regular expression was used instead:  <kbd>preg_match("/[^0-9]/", $n)</kbd></li>
     <li>Deprecated: APPVER has been deprecated and replaced with CI_VERSION for clarity. </li>
diff --git a/user_guide/general/autoloader.html b/user_guide/general/autoloader.html
index 39a0ce6..5ee58da 100644
--- a/user_guide/general/autoloader.html
+++ b/user_guide/general/autoloader.html
@@ -73,6 +73,7 @@
 <li>Helper files found in the "helpers" folder</li>
 <li>Plugins found in the "plugins" folder</li>
 <li>Custom config files found in the "config" folder</li>
+<li>Language files found in the "system/language" folder </li>
 </ul>
 
 <p>To autoload resources, open the <var>application/config/autoload.php</var> file and add the item you want
diff --git a/user_guide/libraries/language.html b/user_guide/libraries/language.html
index 6a74cc9..7cc74b6 100644
--- a/user_guide/libraries/language.html
+++ b/user_guide/libraries/language.html
@@ -115,12 +115,9 @@
 <p>Where <samp>language_key</samp> is the array key corresponding to the line you wish to show.</p>
 
 <p>Note: This function simply returns the line.  It does not echo it for you.</p>
-
-
-
-
-
-
+<h2>Auto-loading Languages</h2>
+<p>If you find that you need a particular language globally throughout your application, you can tell CodeIgniter to auto-load it  during system initialization. This is done by opening the application/config/autoload.php file and adding the language(s) to the autoload array.</p>
+<p>&nbsp;</p>
 </div>
 <!-- END CONTENT -->
 
